home *** CD-ROM | disk | FTP | other *** search
/ Aminet 43 / Aminet 43 (2001)(GTI - Schatztruhe)[!][Jun 2001].iso / Aminet / comm / mail / YAM22src.lha / YAM_CL.c < prev    next >
C/C++ Source or Header  |  2000-11-03  |  23KB  |  544 lines
  1. /***************************************************************************
  2.  
  3.  YAM - Yet Another Mailer
  4.  Copyright (C) 2000  Marcel Beck <mbeck@yam.ch>
  5.  
  6.  This program is free software; you can redistribute it and/or modify
  7.  it under the terms of the GNU General Public License as published by
  8.  the Free Software Foundation; either version 2 of the License, or
  9.  (at your option) any later version.
  10.  
  11.  This program is distributed in the hope that it will be useful,
  12.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  GNU General Public License for more details.
  15.  
  16.  You should have received a copy of the GNU General Public License
  17.  along with this program; if not, write to the Free Software
  18.  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  
  20.  YAM Official Support Site :  http://www.yam.ch
  21.  YAM OpenSource project    :  http://sourceforge.net/projects/yamos/
  22.  
  23. ***************************************************************************/
  24.  
  25. #include "YAM.h"
  26.  
  27. /***************************************************************************
  28.  Private MUI classes
  29. ***************************************************************************/
  30.  
  31. /// Definitions
  32. struct MUI_CustomClass *CL_TextEditor;
  33. struct MUI_CustomClass *CL_BodyChunk;
  34. struct MUI_CustomClass *CL_FolderList;
  35. struct MUI_CustomClass *CL_AddressList;
  36. struct MUI_CustomClass *CL_AttachList;
  37. struct MUI_CustomClass *CL_DDString;
  38. struct MUI_CustomClass *CL_DDList;
  39. struct MUI_CustomClass *CL_MainWin;
  40. struct MUI_CustomClass *CL_PageList;
  41. ///
  42. /// BC_Dispatcher (BodyChunk)
  43. //  Subclass of BodyChunk, can load images from files
  44. SAVEDS ASM ULONG BC_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  45. {
  46.    struct BC_Data *data;
  47.    struct TagItem *tags, *tag;
  48.    int useold;
  49.  
  50.    switch (msg->MethodID)
  51.    {
  52.       case OM_NEW:
  53.          tags = ((struct opSet *)msg)->ops_AttrList;
  54.          obj = (Object *)DoSuperNew(cl, obj,
  55.             MUIA_FixWidth, 16,
  56.             MUIA_FixHeight, 16,
  57.             MUIA_InnerBottom, 0,
  58.             MUIA_InnerLeft, 0,
  59.             MUIA_InnerRight, 0,
  60.             MUIA_InnerTop, 0,
  61.             TAG_MORE, tags);
  62.          if (obj)
  63.          {
  64.             char fname[SIZE_PATHFILE];
  65.             useold = FALSE;
  66.             *fname = 0;
  67.             data = INST_DATA(cl,obj);
  68.             while (tag = NextTagItem(&tags))
  69.             {
  70.                switch (tag->ti_Tag)
  71.                {
  72.                   case MUIA_Bodychunk_UseOld:
  73.                      if (tag->ti_Data) useold = (BOOL)tag->ti_Data;
  74.                      break;
  75.                   case MUIA_Bodychunk_File:
  76.                      if (tag->ti_Data) stccpy(fname, (char *)tag->ti_Data, SIZE_PATHFILE);
  77.                      break;
  78.                }
  79.             }
  80.             if (*fname)
  81.             {
  82.                if (useold) data->BCD = GetBCImage(fname);
  83.                       else data->BCD = LoadBCImage(fname);
  84.                if (data->BCD)
  85.                {
  86.                   set(obj, MUIA_FixWidth,             data->BCD->Width);
  87.                   set(obj, MUIA_FixHeight,            data->BCD->Height);
  88.                   set(obj, MUIA_Bitmap_Width,         data->BCD->Width);
  89.                   set(obj, MUIA_Bitmap_Height,        data->BCD->Height);
  90.                   set(obj, MUIA_Bitmap_SourceColors,  data->BCD->Colors);
  91.                   set(obj, MUIA_Bodychunk_Depth,      data->BCD->Depth);
  92.                   set(obj, MUIA_Bodychunk_Body,       data->BCD->Body);
  93.                   set(obj, MUIA_Bodychunk_Compression,data->BCD->Compression);
  94.                   set(obj, MUIA_Bodychunk_Masking,    data->BCD->Masking);
  95.                   set(obj, MUIA_UserData,             useold);
  96.                }
  97.             }
  98.          }
  99.          return (ULONG)obj;
  100.       case OM_DISPOSE:
  101.          data = INST_DATA(cl,obj);
  102.          get(obj, MUIA_UserData, &useold);
  103.          if (!useold) FreeBCImage(data->BCD);
  104.          break;
  105.    }
  106.    return DoSuperMethodA(cl, obj, msg);
  107. }
  108. ///
  109. /// WS_Dispatcher (Recipient String)
  110. //  Subclass of Betterstring, handles alias auto-completion, drag&drop from address book
  111. SAVEDS ASM ULONG WS_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  112. {
  113.    ULONG result = NULL;
  114.    UBYTE code;
  115.    struct MUIP_DragQuery *d = (struct MUIP_DragQuery *)msg;
  116.    struct WS_Data *data = (struct WS_Data *)INST_DATA(cl,obj);
  117.    struct MUIS_Listtree_TreeNode *active;
  118.    struct MUIP_HandleEvent *hmsg;
  119.    
  120.    switch(msg->MethodID)
  121.    {
  122.       case OM_NEW:
  123.          result = DoSuperNew(cl, obj, StringFrame, MUIA_CycleChain, 1, TAG_MORE, ((struct opSet *)msg)->ops_AttrList);
  124.          break;
  125.       case MUIM_Setup:
  126.          if(DoSuperMethodA(cl, obj, msg))
  127.          {
  128.             data->ehnode.ehn_Priority = 1;
  129.             data->ehnode.ehn_Flags    = 0;
  130.             data->ehnode.ehn_Object   = obj;
  131.             data->ehnode.ehn_Class    = cl;
  132.             data->ehnode.ehn_Events   = IDCMP_RAWKEY;
  133.             result = TRUE;
  134.          }
  135.          break;
  136.       case MUIM_GoActive:
  137.          DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
  138.          result = DoSuperMethodA(cl, obj, msg);
  139.          break;
  140.       case MUIM_GoInactive:
  141.          DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
  142.          set(obj, MUIA_BetterString_SelectSize, 0);
  143.          result = DoSuperMethodA(cl, obj, msg);
  144.          break;
  145.       case MUIM_HandleEvent:
  146.          hmsg = (struct MUIP_HandleEvent *)msg;
  147.          if (hmsg->imsg && hmsg->imsg->Class == IDCMP_RAWKEY)
  148.          {
  149.             char *contents, *newcontents, *completed = NULL, *comma;
  150.             int pos, allowmulti;
  151.             if (hmsg->imsg->Code == 95 && (hmsg->imsg->Qualifier & IEQUALIFIER_CONTROL))
  152.             {
  153.                DoSuperMethodA(cl, obj, msg);
  154.                get(obj, MUIA_String_Contents, &contents);
  155.                get(obj, MUIA_UserData, &allowmulti);
  156.                if (completed = WR_ExpandAddresses(-1, contents, FALSE, !allowmulti))
  157.                {
  158.                   setstring(obj, completed);
  159.                   FreeStrBuf(completed);
  160.                }
  161.                result = MUI_EventHandlerRC_Eat;
  162.             }
  163.             else
  164.             {
  165.                if (hmsg->imsg->Code == 65) DoMethod(obj, MUIM_BetterString_ClearSelected);
  166.                code = ConvertKey(hmsg->imsg);
  167.                if ((((code >= 32 && code <= 126) || code >= 160) && !(hmsg->imsg->Qualifier & IEQUALIFIER_RCOMMAND)) || (code && hmsg->imsg->Qualifier & IEQUALIFIER_CONTROL))
  168.                {
  169.                   DoSuperMethodA(cl, obj, msg);
  170.                   get(obj, MUIA_String_Contents, &contents);
  171.                   get(obj, MUIA_String_BufferPos, &pos);
  172.                   if (strlen(contents) > 1)
  173.                   {
  174.                      if (comma = strrchr(contents,','))
  175.                      {
  176.                         while (*++comma == ' ');
  177.                         if (strlen(comma) > 1) completed = AB_CompleteAlias(comma);
  178.                      }
  179.                      else completed = AB_CompleteAlias(contents);
  180.                      if (completed)
  181.                      {
  182.                         newcontents = malloc(strlen(contents)+strlen(completed)+1);
  183.                         strcpy(newcontents, contents);
  184.                         strcpy(&newcontents[pos], completed);
  185.                         SetAttrs(obj, MUIA_String_Contents,newcontents, MUIA_String_BufferPos,pos, MUIA_BetterString_SelectSize,strlen(newcontents)-pos, TAG_DONE);
  186.                         free(newcontents);
  187.                      }
  188.                   }
  189.                   result = MUI_EventHandlerRC_Eat;
  190.                }
  191.             }
  192.          }
  193.          break;
  194.       case MUIM_DragQuery:
  195.          result = MUIV_DragQuery_Refuse;
  196.          if (d->obj == G->MA->GUI.NL_MAILS) result = MUIV_DragQuery_Accept;
  197.          else if (d->obj == G->AB->GUI.LV_ADRESSES)
  198.             if (active = (struct MUIS_Listtree_TreeNode *)DoMethod(d->obj, MUIM_Listtree_GetEntry, NULL, MUIV_Lt_GetEntry_Position_Active, 0))
  199.                if (!(active->tn_Flags & TNF_LIST)) result = MUIV_DragQuery_Accept;
  200.          break;
  201.       case MUIM_DragDrop:
  202.          if (d->obj == G->MA->GUI.NL_MAILS)
  203.          {
  204.             struct Mail *mail;
  205.             DoMethod(d->obj, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &mail);
  206.             if (OUTGOING(mail->Folder->Type)) AB_InsertAddress(obj, "", mail->To.RealName, mail->To.Address);
  207.             else AB_InsertAddress(obj, "", mail->From.RealName, mail->From.Address);
  208.          }
  209.          else if (d->obj == G->AB->GUI.LV_ADRESSES)
  210.          {
  211.             struct MUIS_Listtree_TreeNode *active = (struct MUIS_Listtree_TreeNode *)DoMethod(d->obj, MUIM_Listtree_GetEntry, NULL, MUIV_Lt_GetEntry_Position_Active, 0);
  212.             struct ABEntry *addr = (struct ABEntry *)(active->tn_User);
  213.             AB_InsertAddress(obj, addr->Alias, addr->RealName, "");
  214.          }
  215.          break;
  216.       default:
  217.          result = DoSuperMethodA(cl, obj, msg);
  218.          break;
  219.    }
  220.    return result;
  221.  
  222. }
  223. ///
  224. /// WL_Dispatcher (Attachment List)
  225. //  Subclass of List, adds Drag&Drop from message list
  226. SAVEDS ASM ULONG WL_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  227. {
  228.    struct MUIP_DragQuery *d = (struct MUIP_DragQuery *)msg;
  229.  
  230.    switch (msg->MethodID)
  231.    {
  232.       case OM_NEW:
  233.          return DoSuperNew(cl, obj, TAG_MORE, ((struct opSet *)msg)->ops_AttrList);
  234.       case MUIM_Setup:
  235.          if (!DoSuperMethodA(cl, obj, msg)) return FALSE;
  236.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  237.          return TRUE;
  238.       case MUIM_Cleanup:
  239.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  240.          break;
  241.       case MUIM_DragQuery:
  242.          if (d->obj == G->MA->GUI.NL_MAILS) return MUIV_DragQuery_Accept;
  243.          break;
  244.       case MUIM_DragDrop:
  245.          if (d->obj == G->MA->GUI.NL_MAILS)
  246.          {
  247.             struct Attach attach;
  248.             struct Mail *mail;
  249.             int id = MUIV_NList_NextSelected_Start;
  250.             while (TRUE)
  251.             {
  252.                DoMethod(d->obj, MUIM_NList_NextSelected, &id); if (id == MUIV_NList_NextSelected_End) break;
  253.                DoMethod(d->obj, MUIM_NList_GetEntry, id, &mail);
  254.                clear(&attach, sizeof(struct Attach));
  255.                GetMailFile(attach.FilePath, NULL, mail);
  256.                stccpy(attach.Description, mail->Subject, SIZE_DEFAULT);
  257.                strcpy(attach.ContentType, "message/rfc822");
  258.                attach.Size = mail->Size;
  259.                attach.IsMIME = TRUE;
  260.                DoMethod(obj, MUIM_List_InsertSingle, &attach, MUIV_List_Insert_Bottom);
  261.             }
  262.             return 0;
  263.          }
  264.          break;
  265.    }
  266.    return DoSuperMethodA(cl, obj, msg);
  267. }
  268. ///
  269. /// FL_Dispatcher (Folder List)
  270. //  Subclass of NList, adds Drag&Drop from message list
  271. SAVEDS ASM ULONG FL_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  272. {
  273.    struct MUIP_DragQuery *dq = (struct MUIP_DragQuery *)msg;
  274.    struct MUIP_NList_DropType *dt = (struct MUIP_NList_DropType *)msg;
  275.    struct Folder *srcfolder, *dstfolder;
  276.    static Object *lastobject = NULL;
  277.    int pos = 0;
  278.  
  279.    switch (msg->MethodID)
  280.    {
  281.       case MUIM_NList_DropType:
  282.          if (lastobject != obj) *(dt->type) = MUIV_NList_DropType_Onto; // else  *(dt->type) = MUIV_NList_DropType_Above;
  283.          break;
  284.       case MUIM_DragQuery:
  285.          lastobject = dq->obj;
  286.          if (dq->obj == obj) break;
  287.          if (dq->obj == G->MA->GUI.NL_MAILS) return MUIV_DragQuery_Accept;
  288.          return MUIV_DragQuery_Refuse;
  289.       case MUIM_DragDrop:
  290.          if (dq->obj == obj) break;
  291.          get(obj, MUIA_NList_DropMark, &pos);
  292.          DoMethod(obj, MUIM_NList_GetEntry, pos, &dstfolder);
  293.          DoMethod(obj, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &srcfolder);
  294.          if (dstfolder->Type != FT_SEPARATOR) MA_MoveCopy(NULL, srcfolder, dstfolder, FALSE);
  295.          return 0;
  296.    }
  297.    return DoSuperMethodA(cl,obj,msg);
  298. }
  299. ///
  300. /// EL_Dispatcher (Member List)
  301. //  Subclass of List, adds Drag&Drop from address book window
  302. SAVEDS ASM ULONG EL_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  303. {
  304.    struct MUIP_DragQuery *d = (struct MUIP_DragQuery *)msg;
  305.    struct MUIS_Listtree_TreeNode *active;
  306.  
  307.    switch (msg->MethodID)
  308.    {
  309.       case MUIM_DragQuery:
  310.          if (d->obj == obj) break;
  311.          if (d->obj == G->AB->GUI.LV_ADRESSES && d->obj != obj)
  312.             if (active = (struct MUIS_Listtree_TreeNode *)DoMethod(d->obj, MUIM_Listtree_GetEntry, NULL, MUIV_Lt_GetEntry_Position_Active, 0))
  313.                if (!((struct ABEntry *)(active->tn_User))->Members) return MUIV_DragQuery_Accept;
  314.          return MUIV_DragQuery_Refuse;
  315.       case MUIM_DragDrop:
  316.          if (d->obj == obj) break;
  317.          if (d->obj == G->AB->GUI.LV_ADRESSES && d->obj != obj)
  318.             if (active = (struct MUIS_Listtree_TreeNode *)DoMethod(d->obj, MUIM_Listtree_GetEntry, NULL, MUIV_Lt_GetEntry_Position_Active, 0))
  319.                if (active->tn_Flags & TNF_LIST) EA_AddMembers(obj, active);
  320.                else EA_AddSingleMember(obj, active);
  321.          return 0;
  322.    }
  323.    return DoSuperMethodA(cl,obj,msg);
  324. }
  325. ///
  326. /// AL_Dispatcher (Address book Listtree)
  327. //  Subclass of Listtree, supports inline images and Drag&Drop from message list
  328. SAVEDS ASM ULONG AL_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  329. {
  330.    struct AL_Data *data;
  331.    struct MUIP_DragQuery *d = (struct MUIP_DragQuery *)msg;
  332.  
  333.    switch (msg->MethodID)
  334.    {
  335.       case OM_NEW:
  336.          obj = (Object *)DoSuperNew(cl, obj, TAG_MORE, ((struct opSet *)msg)->ops_AttrList);
  337.          if (obj)
  338.          {
  339.             struct AL_Data *data = INST_DATA(cl, obj);
  340.             data->DisplayHook.h_Entry = (VOID *)AB_LV_DspFunc;
  341.             data->DisplayHook.h_Data  = (APTR)data;
  342.             set(obj, MUIA_Listtree_DisplayHook, &data->DisplayHook);
  343.          }
  344.          return (ULONG)obj;
  345.       case MUIM_Setup:
  346.          if (!DoSuperMethodA(cl, obj, msg)) return FALSE;
  347.          data = INST_DATA(cl, obj);
  348.          data->Object = NewObject(CL_BodyChunk->mcc_Class,NULL,
  349.                                   MUIA_Bodychunk_File, "status_group",
  350.                                   MUIA_Bodychunk_UseOld, TRUE,
  351.                                   MUIA_Bitmap_Transparent, 0,
  352.                               End;
  353.          data->Image = (APTR)DoMethod(obj, MUIM_List_CreateImage, data->Object, 0);
  354.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  355.          return TRUE;
  356.       case MUIM_Cleanup: 
  357.          data = INST_DATA(cl, obj);
  358.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  359.          DoMethod(obj, MUIM_List_DeleteImage, data->Image);
  360.          if (data->Object) MUI_DisposeObject(data->Object);
  361.       case MUIM_DragQuery:
  362.          if (d->obj == G->MA->GUI.NL_MAILS) return MUIV_DragQuery_Accept;
  363.          break;
  364.       case MUIM_DragDrop:
  365.          if (d->obj == G->MA->GUI.NL_MAILS)
  366.          {
  367.             struct Mail **mlist = MA_CreateMarkedList(d->obj);
  368.             if (mlist) { MA_GetAddress(mlist); free(mlist); }
  369.          }
  370.          break;
  371.    }
  372.    return DoSuperMethodA(cl,obj,msg);
  373. }
  374. ///
  375. /// MW_Dispatcher (Main Window)
  376. //  Subclass of Windows, used to dispose subwindows on exit
  377. struct MUIP_MainWindow_CloseWindow { ULONG MethodID; APTR Window; };
  378. SAVEDS ASM ULONG MW_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  379. {
  380.    if (msg->MethodID == MUIM_MainWindow_CloseWindow)
  381.    {
  382.       APTR app, win = ((struct MUIP_MainWindow_CloseWindow *)msg)->Window;
  383.       set(win, MUIA_Window_Open, FALSE);
  384.       get(win, MUIA_ApplicationObject, &app);
  385.       DoMethod(app, OM_REMMEMBER, win);
  386.       MUI_DisposeObject(win);
  387.    }
  388.    else return DoSuperMethodA(cl, obj, (Msg)msg);
  389. }
  390. ///
  391. /// TE_Dispatcher (Text Editor)
  392. //  Subclass of Texteditor, adds error requester, Drag&Drop capabilities and multi-color support
  393. SAVEDS ASM ULONG TE_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) struct MUIP_TextEditor_HandleError *msg)
  394. {
  395.    switch (msg->MethodID)
  396.    {
  397.       case MUIM_TextEditor_HandleError:
  398.       {
  399.          char *errortxt = NULL;
  400.          switch (msg->errorcode)
  401.          {
  402.             case Error_ClipboardIsEmpty:  errortxt = GetStr(MSG_CL_ErrorEmptyCB); break;
  403.             case Error_ClipboardIsNotFTXT:errortxt = GetStr(MSG_CL_ErrorNotFTXT); break;
  404.             case Error_NoAreaMarked:      errortxt = GetStr(MSG_CL_ErrorNoArea); break;
  405.             case Error_NothingToRedo:     errortxt = GetStr(MSG_CL_ErrorNoRedo); break;
  406.             case Error_NothingToUndo:     errortxt = GetStr(MSG_CL_ErrorNoUndo); break;
  407.             case Error_NotEnoughUndoMem:  errortxt = GetStr(MSG_CL_ErrorNoUndoMem); break;
  408.          }
  409.          if (errortxt) MUI_Request(_app(obj), _win(obj), 0L, NULL, GetStr(MSG_OkayReq), errortxt);
  410.          break;
  411.       }
  412.       case MUIM_Show:
  413.       {
  414.          G->EdColMap[6] = MUI_ObtainPen(muiRenderInfo(obj), &C->ColoredText, 0);
  415.          G->EdColMap[7] = MUI_ObtainPen(muiRenderInfo(obj), &C->Color2ndLevel, 0);
  416.          break;
  417.       }
  418.       case MUIM_Hide:
  419.       {
  420.          if (G->EdColMap[6] >= 0) MUI_ReleasePen(muiRenderInfo(obj), G->EdColMap[6]);
  421.          if (G->EdColMap[7] >= 0) MUI_ReleasePen(muiRenderInfo(obj), G->EdColMap[7]);
  422.          break;
  423.       }
  424.       case MUIM_DragQuery:
  425.       {
  426.          struct MUIP_DragDrop *drop_msg = (struct MUIP_DragDrop *)msg;
  427.          return (ULONG)(drop_msg->obj == G->AB->GUI.LV_ADRESSES);
  428.       }
  429.       case MUIM_DragDrop:
  430.       {
  431.          struct MUIP_DragDrop *drop_msg = (struct MUIP_DragDrop *)msg;
  432.          if (drop_msg->obj == G->AB->GUI.LV_ADRESSES)
  433.          {
  434.             struct MUIS_Listtree_TreeNode *tn;
  435.             if (tn = (struct MUIS_Listtree_TreeNode *)DoMethod(drop_msg->obj, MUIM_Listtree_GetEntry, MUIV_Lt_GetEntry_ListNode_Active, MUIV_Lt_GetEntry_Position_Active, 0))
  436.             {
  437.                struct ABEntry *ab = (struct ABEntry *)(tn->tn_User);
  438.                if (ab->Type != AET_GROUP)
  439.                {
  440.                   char *adr = AllocStrBuf(SIZE_DEFAULT);
  441.                   WR_ResolveName(-1, ab->Alias, &adr, FALSE);
  442.                   DoMethod(obj, MUIM_TextEditor_InsertText, adr, MUIV_TextEditor_InsertText_Cursor);
  443.                   FreeStrBuf(adr);
  444.                }
  445.             }
  446.          }
  447.          break;
  448.       }
  449.    }
  450.    return DoSuperMethodA(cl, obj, (Msg)msg);
  451. }
  452. ///
  453. /// PL_Dispatcher (Config Window Page List)
  454. //  Subclass of List, adds small images to configuration menu
  455. SAVEDS ASM ULONG PL_Dispatcher(REG(a0) struct IClass *cl, REG(a2) Object *obj, REG(a1) Msg msg)
  456. {
  457.    extern UBYTE PL_IconBody[MAXCPAGES][240];
  458.    const ULONG PL_Colors[24] = {
  459.       0x95959595,0x95959595,0x95959595, 0x00000000,0x00000000,0x00000000,
  460.       0xffffffff,0xffffffff,0xffffffff, 0x3b3b3b3b,0x67676767,0xa2a2a2a2,
  461.       0x7b7b7b7b,0x7b7b7b7b,0x7b7b7b7b, 0xafafafaf,0xafafafaf,0xafafafaf,
  462.       0xaaaaaaaa,0x90909090,0x7c7c7c7c, 0xffffffff,0xa9a9a9a9,0x97979797 };
  463.    struct PL_Data *data;
  464.    int i;
  465.  
  466.    switch (msg->MethodID)
  467.    {
  468.       case OM_NEW:
  469.          obj = (Object *)DoSuperNew(cl, obj, TAG_MORE, ((struct opSet *)msg)->ops_AttrList);
  470.          if (obj)
  471.          {
  472.             struct PL_Data *data = INST_DATA(cl,obj);
  473.             data->DisplayHook.h_Entry = (VOID *)CO_PL_DspFunc;
  474.             data->DisplayHook.h_Data  = (APTR)data;
  475.             set(obj, MUIA_List_DisplayHook, &data->DisplayHook);
  476.          }
  477.          return (ULONG)obj;
  478.       case MUIM_Setup:
  479.          if (!DoSuperMethodA(cl, obj, msg)) return FALSE;
  480.          data = INST_DATA(cl, obj);
  481.          for (i = 0; i < MAXCPAGES; i++)
  482.          {
  483.             data->Object[i] = BodychunkObject,
  484.                MUIA_FixWidth             , 23,
  485.                MUIA_FixHeight            , 15,
  486.                MUIA_Bitmap_Width         , 23,
  487.                MUIA_Bitmap_Height        , 15,
  488.                MUIA_Bitmap_SourceColors  , PL_Colors,
  489.                MUIA_Bodychunk_Depth      , 3,
  490.                MUIA_Bodychunk_Body       , PL_IconBody[i],
  491.                MUIA_Bodychunk_Compression, 1,
  492.                MUIA_Bodychunk_Masking    , 2,
  493.                MUIA_Bitmap_Transparent   , 0,
  494.             End;
  495.             data->Image[i] = (APTR)DoMethod(obj, MUIM_List_CreateImage, data->Object[i], 0);
  496.          }
  497.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  498.          return TRUE;
  499.       case MUIM_Cleanup:
  500.          data = INST_DATA(cl, obj);
  501.          MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY);
  502.          for (i = 0; i < MAXCPAGES; i++)
  503.          {
  504.             DoMethod(obj, MUIM_List_DeleteImage, data->Image[i]);
  505.             if (data->Object[i]) MUI_DisposeObject(data->Object[i]);
  506.          }
  507.    }
  508.    return DoSuperMethodA(cl, obj, msg);
  509. }
  510. ///
  511.  
  512. /// ExitClasses
  513. //  Remove custom MUI classes
  514. void ExitClasses(void)
  515. {
  516.    if (CL_PageList   ) MUI_DeleteCustomClass(CL_PageList   );
  517.    if (CL_MainWin    ) MUI_DeleteCustomClass(CL_MainWin    );
  518.    if (CL_TextEditor ) MUI_DeleteCustomClass(CL_TextEditor );
  519.    if (CL_BodyChunk  ) MUI_DeleteCustomClass(CL_BodyChunk  );
  520.    if (CL_FolderList ) MUI_DeleteCustomClass(CL_FolderList );
  521.    if (CL_AddressList) MUI_DeleteCustomClass(CL_AddressList);
  522.    if (CL_DDString   ) MUI_DeleteCustomClass(CL_DDString   );
  523.    if (CL_DDList     ) MUI_DeleteCustomClass(CL_DDList     );
  524.    if (CL_AttachList ) MUI_DeleteCustomClass(CL_AttachList );
  525. }
  526. ///
  527. /// InitClasses
  528. //  Initialize custom MUI classes
  529. BOOL InitClasses(void)
  530. {
  531.    CL_AttachList  = MUI_CreateCustomClass(NULL, MUIC_List         , NULL, sizeof(struct DumData), WL_Dispatcher);
  532.    CL_DDList      = MUI_CreateCustomClass(NULL, MUIC_List         , NULL, sizeof(struct DumData), EL_Dispatcher);
  533.    CL_DDString    = MUI_CreateCustomClass(NULL, MUIC_BetterString , NULL, sizeof(struct WS_Data), WS_Dispatcher);
  534.    CL_AddressList = MUI_CreateCustomClass(NULL, MUIC_Listtree     , NULL, sizeof(struct AL_Data), AL_Dispatcher);
  535.    CL_FolderList  = MUI_CreateCustomClass(NULL, MUIC_NList        , NULL, sizeof(struct DumData), FL_Dispatcher);
  536.    CL_BodyChunk   = MUI_CreateCustomClass(NULL, MUIC_Bodychunk    , NULL, sizeof(struct BC_Data), BC_Dispatcher);
  537.    CL_TextEditor  = MUI_CreateCustomClass(NULL, MUIC_TextEditor   , NULL, sizeof(struct DumData), TE_Dispatcher);
  538.    CL_MainWin     = MUI_CreateCustomClass(NULL, MUIC_Window       , NULL, sizeof(struct DumData), MW_Dispatcher);
  539.    CL_PageList    = MUI_CreateCustomClass(NULL, MUIC_List         , NULL, sizeof(struct PL_Data), PL_Dispatcher);
  540.    return (BOOL)(CL_AttachList && CL_DDList && CL_DDString && CL_AddressList && CL_FolderList && CL_BodyChunk &&
  541.                  CL_TextEditor && CL_MainWin && CL_PageList);
  542. }
  543. ///
  544.